package com.woniu.controller;

import cn.dev33.satoken.util.SaResult;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.woniu.entity.RelUserContest;
import com.woniu.mapper.RelUserContestMapper;
import com.woniu.service.impl.RelUserContestServiceImpl;
import jakarta.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 用户表和考试表关系表控制器
 * @Author pml
 * @Date 2025/6/9 23:46
 * @Description TODO
 **/
@RestController
@RequestMapping("relusercontest")
@CrossOrigin
public class RelUserContestController {

//    @Resource
//    private RelUserContestMapper relUserContestMapper;
    @Autowired
    private RelUserContestServiceImpl   relUserContestService;

    /**
     * @Author pml
     * 新增用户-考试关联
     * 调用Service层方法处理业务逻辑，Controller不直接操作数据库
     * @param rel 关联关系实体
     * @return 操作结果
     */
    @PostMapping("/add")
    public SaResult add(@RequestBody RelUserContest rel) {
//        // 校验必填参数
//        if (rel.getContestId() == null || rel.getUserId() == null) {
//            return SaResult.error("考试ID和用户ID不能为空");
//        }
//        // 避免重复关联（查询是否已存在）
//        QueryWrapper<RelUserContest> wrapper = Wrappers.query();
//        wrapper.eq("contest_id", rel.getContestId())
//                .eq("user_id", rel.getUserId());
//        if (relUserContestMapper.selectCount(wrapper) > 0) {
//            return SaResult.error("该用户与考试已关联");
//        }
//        // 插入关联关系
//        relUserContestMapper.insert(rel);
//        return SaResult.ok("关联成功");
        // 调用Service层处理业务逻辑，Controller只处理请求和响应
        String result = relUserContestService.addRelUserContest(rel);
        // 根据Service返回结果构建统一响应格式
        return "关联成功".equals(result) ? SaResult.ok(result) : SaResult.error(result);
    }

    /**
     * @Author pml
     * 删除用户-考试关联
     * 使用RESTful风格URL，清晰表达资源操作
     * @param contestId 考试ID
     * @param userId 用户ID
     * @return 操作结果
     */
    @DeleteMapping("/delete/{contestId}/{userId}")
    public SaResult delete(
            @PathVariable("contestId") Integer contestId,
            @PathVariable("userId") Integer userId
    ) {
//        Map<String, Object> deleteMap = new HashMap<>();
//        deleteMap.put("contest_id", contestId);
//        deleteMap.put("user_id", userId);
//        int rows = relUserContestMapper.deleteByMap(deleteMap);
//        if (rows > 0) {
//            return SaResult.ok("删除关联成功");
//        }
//        return SaResult.error("未找到该关联关系");
        String result = relUserContestService.deleteRelUserContest(contestId, userId);
        return "删除关联成功".equals(result) ? SaResult.ok(result) : SaResult.error(result);
    }

    /**
     * @Author pml
     * 根据考试ID查询关联的用户ID列表
     * 接口职责单一，只返回用户ID列表
     * @param contestId 考试ID
     * @return 用户ID列表
     */
    @GetMapping("/listByContest/{contestId}")
    public SaResult listByContest(@PathVariable Integer contestId) {
//        QueryWrapper<RelUserContest> wrapper = Wrappers.query();
//        wrapper.select("user_id")  // 只查询用户ID字段
//                .eq("contest_id", contestId);
//        List<RelUserContest> relList = relUserContestMapper.selectList(wrapper);
//        // 提取用户ID列表（转换为 Integer 集合）
//        List<Integer> userIdList = relList.stream()
//                .map(RelUserContest::getUserId)
//                .toList();
//        return SaResult.ok().setData(userIdList);
        List<Integer> userIdList = relUserContestService.listUserIdsByContestId(contestId);
        return SaResult.ok().setData(userIdList);
    }

    /**
     * @Author pml
     * 根据用户ID查询关联的考试ID列表
     * 接口职责单一，只返回考试ID列表
     * @param userId 用户ID
     * @return 考试ID列表
     */
    @GetMapping("/listByUser/{userId}")
    public SaResult listByUser(@PathVariable Integer userId) {
//        QueryWrapper<RelUserContest> wrapper = Wrappers.query();
//        wrapper.select("contest_id")  // 只查询考试ID字段
//                .eq("user_id", userId);
//        List<RelUserContest> relList = relUserContestMapper.selectList(wrapper);
//        // 提取考试ID列表（转换为 Integer 集合）
//        List<Integer> contestIdList = relList.stream()
//                .map(RelUserContest::getContestId)
//                .toList();
//        return SaResult.ok().setData(contestIdList);
        List<Integer> contestIdList = relUserContestService.listContestIdsByUserId(userId);
        return SaResult.ok().setData(contestIdList);
    }

    /**
     * @Author pml
     * 查询所有关联记录
     * 使用Service层的list方法，无需关注具体实现
     * @return 所有关联记录
     */
    @GetMapping("/list")
    public SaResult list() {
//        return SaResult.ok().setData(relUserContestMapper.selectList(null));
        return SaResult.ok().setData(relUserContestService.list());
    }

    /**
     * @Author pml
     * 根据考试ID批量删除关联记录
     * 调用Service层事务方法，确保数据一致性
     * @param contestId 考试ID
     * @return 操作结果
     */
    @DeleteMapping("/deleteByContest/{contestId}")
    @Transactional
    public SaResult deleteByContest(@PathVariable Integer contestId) {
//        QueryWrapper<RelUserContest> wrapper = Wrappers.query();
//        wrapper.eq("contest_id", contestId);
//        int rows = relUserContestMapper.delete(wrapper);
//        if (rows > 0) {
//            return SaResult.ok("成功删除" + rows + "条关联记录");
//        }
//        return SaResult.error("未找到相关关联记录");
        String result = relUserContestService.deleteByContestId(contestId);
        return result.startsWith("成功") ? SaResult.ok(result) : SaResult.error(result);
    }
}